home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus Special 18 / AMIGAplus Sonderheft 18 (1999)(ICP)(DE)[!].iso / PD / Spiele / InvasionForce / Source / Includes / global..bak < prev    next >
Text File  |  1999-01-08  |  16KB  |  443 lines
  1. // global.h -- global definitions header
  2.  
  3. // various types of headers
  4. #include <dos/dos.h>
  5. #include <intuition/intuition.h>
  6. #include <intuition/screens.h>
  7. #include <intuition/gadgetclass.h>
  8. #include <libraries/gadtools.h>
  9. #include <libraries/asl.h>
  10.  
  11. #include <clib/exec_protos.h>
  12. #include <clib/graphics_protos.h>
  13. #include <clib/intuition_protos.h>
  14. #include <clib/gadtools_protos.h>
  15.  
  16. #include <exec/memory.h>
  17.  
  18. #include <proto/intuition.h>
  19. #include <proto/dos.h>
  20. #include <proto/exec.h>
  21. #include <proto/diskfont.h>
  22. #include <proto/graphics.h>
  23. #include <proto/gadtools.h>
  24. #include <proto/asl.h>
  25.  
  26. #include <stdlib.h>
  27. #include <stdio.h>
  28. #include <time.h>
  29. #include <string.h>
  30.  
  31. #undef strcpy
  32.  
  33. #include <libraries/reqtools.h>
  34. #include <proto/reqtools.h>
  35.  
  36. // These make the code easier to follow.
  37. #define FI }
  38. #define OD }
  39. #define Bool(a) ((a)!=0)   // explicitly converts any numeric or bit value
  40.                            // to TRUE or FALSE
  41.  
  42. // sound and music support
  43. #include "sound_protos.h"
  44. #include "libproto.h"
  45.  
  46. // These common default tags for my EZ Requesters
  47. #define RT_DEFAULT RT_Window,map_window,RT_ReqPos,REQPOS_CENTERWIN,RT_LockWindow,TRUE
  48.  
  49. #define IDCMP_MAPEDIT (IDCMP_MENUPICK|IDCMP_MOUSEBUTTONS|IDCMP_MOUSEMOVE|SCROLLERIDCMP|IDCMP_RAWKEY|IDCMP_VANILLAKEY)
  50. #define IDCMP_PLAYGAME (IDCMP_MENUPICK|IDCMP_MOUSEBUTTONS|SCROLLERIDCMP|IDCMP_RAWKEY|IDCMP_VANILLAKEY|IDCMP_INTUITICKS)
  51.  
  52. extern ULONG __far RangeSeed;  // This is needed for random number generation.
  53.  
  54. // the parameters that get me a standard busy pointer
  55. #define BUSY_POINTER busy_pointer_data,16,16,-6,0
  56.  
  57. // locations of the special map objects in my graphics bitmap
  58. #define MAP_CURSOR 242,30
  59. #define MAP_MARKER 242,48
  60. #define MAP_BLAST 154,30
  61.  
  62. // pen colors
  63. #define LT_GRAY   0
  64. #define BLACK     1
  65. #define WHITE     2
  66. #define LT_BLUE   3
  67. #define TAN       4
  68. #define DK_GRAY   5
  69. #define PURPLE    6
  70. #define ORANGE    7
  71. #define RED       8
  72. #define DK_BLUE   9
  73. #define BLUE      10
  74. #define BROWN     11
  75. #define GRAY      12
  76. #define DK_GREEN  13
  77. #define LT_GREEN  14
  78. #define GREEN     15
  79.  
  80. // terrain hex ID codes
  81. #define HEX_UNEXPLORED  0
  82. #define HEX_PLAINS      1
  83. #define HEX_DESERT      2
  84. #define HEX_FORBID      3
  85. #define HEX_ARCTIC      3
  86. #define HEX_BRUSH       4
  87. #define HEX_FOREST      5
  88. #define HEX_JUNGLE      6
  89. #define HEX_RUGGED      7
  90. #define HEX_HILLS       8
  91. #define HEX_MOUNTAINS   9
  92. #define HEX_PEAKS       10
  93. #define HEX_SWAMP       11
  94. #define HEX_SHALLOWS    12
  95. #define HEX_OCEAN       13
  96. #define HEX_DEPTH       14
  97. #define HEX_ICE         15
  98. #define HEX_CITY        16    // not a real hex, but a valid brush value
  99. #define HEX_ROADS       17    // ditto!
  100.  
  101. // following macro easily determines if a hex is ocean (ice doesn't count)
  102. #define OCEAN_P(a) (a>=HEX_SHALLOWS&&a<=HEX_DEPTH)
  103.  
  104. #define VALID_HEX(a,b) ((BOOL)(a>=0&&a<width&&b>=0&&b<height))
  105.  
  106. #define GRID_SIZE ((long)((width+width%2)*height/2+1))
  107.  
  108. #define ROAD 1     // flags show presence of roads or minefields
  109. #define MINE 2
  110.  
  111. // unit-icon ID codes
  112. // the first 12 are also used to identify unit types
  113. #define RIFLE        0
  114. #define ARMOR        1
  115. #define AIRCAV       2
  116. #define BOMBER       3
  117. #define FIGHTER      4
  118. #define TRANSPORT    5
  119. #define SUB          6
  120. #define DESTROYER    7
  121. #define CRUISER      8
  122. #define BATTLESHIP   9
  123. #define CARRIER      10
  124. #define AIRFIELD     11
  125.  
  126. // these aren't properly unit types
  127. #define LANDMINE     17
  128. #define SEAMINE      18
  129. #define MILITIA      20
  130. #define CITY         21
  131. #define ROADS        22
  132.  
  133. // map display info
  134. // minimum width and height designed for NTSC, no overscan
  135. #define MIN_WD 19
  136. #define MIN_HT 14
  137.  
  138. // this is the visible overlap around the edges of the map when
  139. // using wrap-around
  140. #define WRAP_OVERLAP 3
  141.  
  142. extern BOOL fmail;
  143.  
  144. extern BOOL modem;
  145.  
  146. struct Hex_Coords {
  147.    short col, row;
  148. };
  149.  
  150. // global game options
  151. struct Opt {
  152.    int gametype;        // normal, file-mail, or modem
  153.    BOOL wrap;           // wrap-around map
  154.    BOOL defend_cities;  // units in a city help defend it
  155.    BOOL fortification;  // allow units to dig in?
  156.    BOOL stacking;       // none, partial (in movement), full
  157.    BOOL landmines;      // landmines enabled?
  158.    BOOL seamines;       // seamines enabled?
  159. };    // opt;
  160.  
  161. struct OldCity {     // KEPT FOR COMPATIBILITY
  162.    struct MinNode cnode;
  163.    short col, row;   // location on map
  164.    short unit_type;  // what it's producing
  165.    short unit_wip;   // Work In Progress, how much it's already built
  166.    short owner;      // who owns dis joint?
  167.    short industry;   // production capacity, defaults to 50%
  168.    APTR reserved;    // reserved for what, I just don't know
  169.    char name[20];    // name of city
  170. };
  171.  
  172. struct City {
  173.    struct MinNode cnode;
  174.    short col, row;   // location on map
  175.    short unit_type;  // what it's producing
  176.    short unit_wip;   // Work In Progress, how much it's already built
  177.    short owner;      // who owns dis joint?
  178.    short industry;   // production capacity, defaults to 50%
  179.    short specialty;  // the unit type this city specializes in,
  180.                      // or 12 (CITY) means no specialty
  181.    short reserved;
  182.    char name[20];    // name of city
  183.    UBYTE recon[9];   // recon value for each player
  184. };
  185.  
  186.  
  187. // valid order codes that can be given
  188. // each of these conditions has a graphical token associated with it
  189. #define ORDER_NONE      0
  190. #define ORDER_SENTRY    1
  191. #define ORDER_FORTIFY   2
  192. #define ORDER_FORTIFIED 3
  193. #define ORDER_LOAD      4
  194. #define ORDER_UNLOAD    5
  195. #define ORDER_GOTO      6
  196.  
  197. // These two are NOT associated with graphical tokens - use carefully
  198. #define ORDER_HOME      10
  199. #define ORDER_PATROL    11
  200.  
  201. struct OldOrder { // obsolete; intended only for compatibility purposes
  202.    short type;    // code for the type of order
  203.    short orgx,  orgy;       // origin coordinates (Quit smirking!)
  204.    short destx, desty;      // destination coordinates
  205.    short etc;     // Estimated Time of Completion; the turn number when a
  206.                   // non-movement activity will be finished, such as
  207.                   // fortification, minelaying, etc.
  208.    struct Unit *dest_unit;  // destination unit (i.e. aircraft carrier)
  209. };
  210.  
  211. struct Order {
  212.    short type;    // code for the type of order
  213.    short orgx,  orgy;       // origin coordinates (Quit smirking!)
  214.    short destx, desty;      // destination coordinates
  215.    short etc;     // Estimated Time of Completion; the turn number when a
  216.                   // non-movement activity will be finished, such as
  217.                   // fortification, minelaying, etc.
  218.    short reserved;
  219.    BOOL processed;     // flag shows whether this unit has been processed
  220.                        // by the order manager this turn
  221.    struct Unit *dest_unit;  // destination unit (i.e. aircraft carrier)
  222. };
  223.  
  224.  
  225. /*
  226.    If you change the UnitTemplate data structure, be sure to also change
  227.    the wishbook[] initialization in data_struct.c!
  228. */
  229.  
  230. struct UnitTemplate {
  231.    int type;         // type of unit to build (NOT USED)
  232.    int build;        // amount of industry units needed to build one
  233.    int range;        // number of movement units without refueling (-1 = unlimited)
  234.    int speed;        // number of movement units per turn
  235.    int hitpoints;    // number of hits it can take without being destroyed
  236.    BOOL enabled;     // available in this game, true or false
  237.    BOOL ship_flag;   // set TRUE if it can only be built in port cities
  238.    char name[20];    // name of unit type "RIFLE", "TRANSPORT", etc.
  239. };    // wishbook[13]
  240.  
  241. struct InfoTemplate {
  242.    BOOL enabled;
  243. };
  244.  
  245.  
  246. struct OldUnit {
  247.    struct MinNode unode;
  248.    short col, row;   // location of the piece
  249.    short owner;      // who owns the piece
  250.    short type;       // what kind of piece it is
  251.    short damage;     // how many hits it has taken
  252.    short attacks;    // how many attacks it has made this turn
  253.    short cargo;      // how many cargo units are on board
  254.    short move;       // how many 1/60 spaces it can move this turn
  255.    short fuel;       // how many turns remain before refueling
  256.    struct Unit *ship;     // ship that is carrying this unit or NULL
  257.    struct Order *orders;  // pointer to the piece's current orders or NULL
  258.    char *name;       // pointer to name of unit, otherwise NULL
  259. };
  260.  
  261. struct Unit {
  262.    struct MinNode unode;
  263.    short col, row;   // location of the piece
  264.    short owner;      // who owns the piece
  265.    short type;       // what kind of piece it is
  266.    short damage;     // how many hits it has taken
  267.    short attacks;    // how many attacks it has made this turn
  268.    short cargo;      // how many cargo units are on board
  269.    short weight;     // how much cargo weight it's carrying
  270.                      // (rifle=1, armor=2, fighter=1)
  271.    short move;       // how many 1/60 spaces it can move this turn
  272.    short fuel;       // how many turns remain before refueling
  273.    long reserved;
  274.    struct Unit *ship;     // ship that is carrying this unit or NULL
  275.    struct Order *orders;  // pointer to the piece's current orders or NULL
  276.    char *name;       // pointer to name of unit, otherwise NULL
  277. };
  278.  
  279.  
  280. #define mask(a) (1<<a) // used for bitwise tests
  281.  
  282. enum PlayerType { NOPLAYER, HUMAN, COMPUTER, NEUTRAL, COMP2, COMP3, AREXX };
  283. enum SoundFX { SOUND_ALL, SOUND_BATTLE, SOUND_NONE };
  284. enum PlayerStatus { ACTIVE, CRUSHED, SURRENDERED };
  285.  
  286. /*
  287.    The following flag values define possible return values of unit_readiness().
  288.    This has been changed from the previous method of using enumerated values,
  289.    because I found it might be useful for some of the states to overlap.
  290. */
  291. #define UNIT_UNREADY    1
  292. #define UNIT_READY      (1<<1)
  293. #define UNIT_ENGAGED    (1<<2)
  294. #define UNIT_PROCESSED  (1<<3)
  295.  
  296. // these were the previous values...
  297. // enum UnitStatus { UNIT_UNREADY, UNIT_READY, UNIT_ENGAGED, UNIT_PROCESSED };
  298.  
  299. #define ISHUMAN(x) (x==HUMAN)
  300. #define NONHUMAN(x) (x>=COMPUTER&&x<=AREXX)
  301.  
  302. struct OldMapIcon {     // an object to display on the user's map
  303.    struct MinNode inode;
  304.    short col, row;   // location on player's map
  305.    short type;       // icon number (or city)
  306.    short owner;      // what player it belongs to
  307.    short token;      // show order status
  308.    BOOL stacked;     // draw heavy border
  309. };
  310.  
  311. struct MapIcon {     // an object to display on the user's map
  312.    struct MinNode inode;
  313.    short col, row;   // location on player's map
  314.    short type;       // icon number (or city)
  315.    short owner;      // what player it belongs to
  316.    short token;      // show order status
  317.    short turn;       // turn number when the icon was made
  318.    BOOL stacked;     // draw heavy border
  319. };
  320.  
  321. struct OldPLayer {   // obsolete structure; kept only for compatibility
  322.    char name[41];             // the player's chosen name
  323.    char passkey[41];          // the player's encrypted password
  324.    enum PlayerType type;      // human or computer?
  325.    enum PlayerStatus status;  // active, crushed, surrendered, whatever...
  326.    short color;               // the color used to indentify his units
  327.    short prod;                // production efficiency, range 0 to 100
  328.    short att;                 // attack efficiency, range 0 to 100
  329.    short def;                 // defense efficiency, range 0 to 100
  330.    short aggr;                // computer aggressiveness, range 1 to 10
  331.    // these next few are user-set preferences
  332.    short msg_delay;           // time delay for user event messages
  333.    short battle_delay;        // time delay for combat events
  334.    enum SoundFX soundfx;      // sound effects: none, all, or battle sounds only
  335.    BOOL autorpt;              // show combat report automatically each turn?
  336.    BOOL show_production;      // automatically show new units produced (not ships)
  337.    // next two are for map data
  338.    char *map;                 // the player's personal battle map
  339.    struct MinList icons;      // list of icons to display for his map
  340.    // eud[] & uld[] store statistics for the war report, have no effect on game
  341.    short eud[11];             // Enemy Units Destroyed
  342.    short ulc[11];             // Units Lost in Combat
  343. };
  344.  
  345. /*
  346.    I have added a new value to the PLayer structure.  This is the "show" value
  347.    which determines whether game actions for this player are displayed on
  348.    screen.  Normally this will have a value of SHOW_NON for computer opponents
  349.    and SHOW_ALL for human players.  However, it is possible to add other modes
  350.    for demonstrations, debugging, etc.
  351. */
  352. #define SHOW_NON   0  // show nothing on screen: no map display, etc.
  353. #define SHOW_GRP   1  // show map display and graphics action
  354. #define SHOW_SND   2  // play sounds
  355. #define SHOW_REQ   4  // present requesters and other events requiring human input
  356. #define SHOW_ALL   (SHOW_GRP|SHOW_SND|SHOW_REQ)
  357.  
  358. struct PLayer {
  359.    char name[41];             // the player's chosen name
  360.    char passkey[41];          // the player's encrypted password
  361.    enum PlayerType type;      // human or computer?
  362.    enum PlayerStatus status;  // active, crushed, surrendered, whatever...
  363.    short show;   // display status of this player; see notes above
  364.    short color;               // the color used to indentify his units
  365.    short prod;                // production efficiency, range 0 to 100
  366.    short att;                 // attack efficiency, range 0 to 100
  367.    short def;                 // defense efficiency, range 0 to 100
  368.    short aggr;                // computer aggressiveness, range 1 to 10
  369.    short reserved1;
  370.    // these next few are user-set preferences
  371.    short snd_vol;             // sound effects volume
  372.    short msg_delay;           // time delay for user event messages
  373.    short battle_delay;        // time delay for combat events
  374.    enum SoundFX soundfx;      // sound effects: none, all, or battle sounds only
  375.    BOOL autorpt;              // show combat report automatically each turn?
  376.    BOOL show_production;      // automatically show new units produced (not ships)
  377.    // next two are for map data
  378.    char *map;                 // the player's personal battle map
  379.    struct MinList icons;      // list of icons to display for his map
  380.    // eud[] & uld[] store statistics for the war report, have no effect on game
  381.    short eud[11];             // Enemy Units Destroyed
  382.    short ulc[11];             // Units Lost in Combat
  383. }; // roster[9];
  384.  
  385. struct Options {
  386.    short num_playing;         // number of players who started
  387.    BOOL stacking;             // whether stacking rules are in force
  388.    BOOL fmail;                // flag for an F-Mail game
  389.    BOOL modem;                // flag for a modem game
  390.    BOOL defend_cities;        // will units help protect a city?
  391.    BOOL entrenchment;         // can troops dig in?
  392. };
  393.  
  394. enum Direction { EAST, SOUTHEAST, SOUTHWEST, WEST, NORTHWEST, NORTHEAST };
  395.  
  396. #define PLAYER roster[player]
  397.  
  398. /*
  399.    This following structure is used with a temporary file to store all
  400.    the combat that takes place.
  401. */
  402.  
  403. struct BattleRecord {
  404.    int turn;  // turn the battle took place
  405.    int att_x, att_y;             // attacker and defender info
  406.    int att_owner, att_type;
  407.    int def_x, def_y;
  408.    int def_owner;
  409.    short white_icon, def_type;
  410.    int winner;   // who won the battle
  411.    int casualties;   // number of defending units destroyed
  412.    int bombardment;  // true if winner does not move
  413.    int seen_by;   // masks indicate who should see this report
  414.    unsigned int blows;   // stores blow-by-blow account
  415. };
  416.  
  417. /*
  418.    The use of the "blows" variable demands more explanation.  The
  419.    first byte of the value is an unsigned char from 1 to 24.  This is
  420.    the number of explosions or "blows" delivered in the fight.  The
  421.    remaining 24 bits each signify an explosion, with 1 being a hit against
  422.    the defender and 0 being a hit against the attacker.
  423. */
  424.  
  425. // automatically generated prototypes
  426. #include "main_menu_protos.h"
  427. #include "map_editor_protos.h"
  428. #include "map_editor2_protos.h"
  429. #include "graphics_protos.h"
  430. #include "map_grafx_protos.h"
  431. #include "data_struct_protos.h"
  432. #include "map_display_protos.h"
  433. #include "game_play1_protos.h"
  434. #include "game_play2_protos.h"
  435. #include "options_protos.h"
  436. #include "Gadgets_protos.h"
  437. #include "Utils_protos.h"
  438. #include "Sound.H"
  439. #include "status_protos.h"
  440. #include "cyber_protos.h"
  441.  
  442. // end of listing
  443.